/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package tetris_invader.personagens;

import java.awt.Image;
import java.awt.Toolkit;
import java.io.*;
import java.net.URL;
import tetris_invader.util.Fase;

public abstract class Invasor extends Animacao implements Serializable {

    /**
     * Passada dos invasores. Cada tipo tem uma passada diferente
     */
    protected int passo;
    /**
     * Flag para saber se ele ja desceu anteriormente ou nao
     */
    private int desceu;
    /**
     * quantidade de delay para o nao se realizar disparos multiplos
     */
    private int tiroDelay;

    public Invasor() {
    }

    public Invasor(Fase f, Image[] imagens, int fps) {
        super(f, imagens, fps);

        size = 25;
        tiroDelay = 0;
        desceu = 0;
    }

    public void setFase(Fase fase)
    {
        this.f = fase;
    }

    public int getPasso() {
        return passo;
    }

    public void setPasso(int passo) {
        this.passo = passo;
    }

    /**
     * Troca o sentido de deslocamento
     */
    public void revertePasso() {
        this.passo = -this.passo;
    }

    /**
     * delay do tiro, para que um invasor nao realize inumeros disparos
     * @return
     */
    public boolean tiroDelay() {
        if (tiroDelay == 0) {
            tiroDelay++;
            return true;
        } else if (tiroDelay >= 6) {
            tiroDelay = 0;
        } else {
            tiroDelay++;
        }
        return false;

    }

    @Override
    public void setVelocidade(float velocidade) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    /**
     * Funcao que realiza o deslocamento do invasor.<br>
     * Caso ele chegue em algum canto, ele recebe uma descida de posicao vertical
     * e seu sentido de deslocamento horizontal é alterado
     */
    @Override
    public void deslocamento() {
        if (point.y <= 10) {
            point.y += 7;
        } else {
            point.x += passo;
            if (point.x >= this.f.getSize().width && desceu == 0) {
                point.y += 32;
                desceu++;
                this.passo = -this.passo;
            } else if (point.x <= 0 && desceu == 0) {
                point.y += 32;
                desceu++;
                this.passo = -this.passo;
            } else if (desceu > 5) {
                desceu = 0;
            } else {
                desceu++;
            }
        }
    }

    public void desce() {
        point.y += 6;
    }

    @Override
    public boolean perdeVida() {
        this.vida -= 1;
        return (vida == 0);
    }

    /**
     * Caso dois invasores estejam na mesma posicao, eles trocam de sentido.<br>
     * Caso os dois estejam indo na mesma direcao, apenas o que veio de encontro
     * ao primeiro é que troca de sentido de caminhada.<br>
     * Verifica-se o invasor <i>this</i> em relacao ao do parametro
     *
     * @param invader personagem com quem vai se verificar colisao
     * @return true se há colisao
     */
    public boolean colisao(Invasor invader) {
        boolean ret = false;
        if (this.positionError(invader.getPosition())) {
            if ((this.passo > 0 && invader.passo > 0)
                    || (this.passo < 0 && invader.passo < 0)) {
                this.revertePasso();
            } else {
                this.revertePasso();
                invader.revertePasso();
            }
            ret = true;
        }
        return ret;
    }

    /**
     * Funcao que calcula colisao com o invasor.
     * Seu resultado é a apresentação de uma explosao, ou a morte
     * do invasor ao ser atingido por um laser, ou bomba
     */
    public void explode() {
        //Verificar colisao com bombo, ou tiro
    }

    private void writeObject(ObjectOutputStream o) throws IOException {
        o.writeInt(passo);
    }

    private void readObject(ObjectInputStream o) throws IOException, ClassNotFoundException {
        passo = o.readInt();
    }

    public int getSize() {
        return size;
    }

    public void setImage() {
        this.imagens = new Image[1];

        String filename = "/images/explode.gif";
        URL url = Fabrica.class.getResource(filename);
        imagens[0] = Toolkit.getDefaultToolkit().getImage(url);
        imagens[0] = imagens[0].getScaledInstance(40, 40, 1);
    }
}
//FIXME colisao as vezes falha: um corre mais e sobrepoe outro
//        boolean erro = false;
//
//        if (erroX(p) && erroY(p)) {
//            erro = true;
//        }
//
//        return erro;
//
//
//
//    /**
//     * Verifica se o objeto que se quer comparar está dentro de um erro na
//     * coordenada x.
//     * @param p Ponto do objeto que se quer comparar
//     * @return <i>true</i> se o valor esta dentro do erro da posicao (sobreposicao
//     * de imagens)
//     */
//    private boolean erroX(Point p) {
//        if (((point.x <= p.x + size*5/4 && point.x >= p.x + size) //Verificacao da direita
//                || (point.x + size >= p.x - size&& point.x + size <= p.x + size))) {//Verificacao da esquerda
//            return true;
//        }
//        return false;
//
//    }
//
//    /**
//     * Verifica se o objeto que se quer comparar está dentro de um erro na
//     * coordenada y.
//     * @param p Ponto do objeto que se quer comparar
//     * @return <i>true</i> se o valor esta dentro do erro da posicao (sobreposicao
//     * de imagens)
//     */
//    private boolean erroY(Point p) {
//        if (((point.y + size <= p.y + size && point.y + size >= p.y) //Verificacao de cima
//                || (point.y >= p.y && point.y <= p.y + size))) {//Verificacao de baixo
//            return true;
//        }
//        return false;
//    }

